Newt.h

Go to the documentation of this file.

/*
*******************************************************************************************************
Copyright (c) 2016, Christopher John Topping, Aarhus University
All rights reserved.
 
Redistribution and use in source and binary forms, with or without modification, are permitted provided
that the following conditions are met:
 
Redistributions of source code must retain the above copyright notice, this list of conditions and the
following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
the following disclaimer in the documentation and/or other materials provided with the distribution.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
********************************************************************************************************
*/
//---------------------------------------------------------------------------
#ifndef NewtH
#define NewtH
//---------------------------------------------------------------------------
 
#define  __NewtDebug
 
//---------------------------------------------------------------------------
 
class Newt_Base;
class Newt_Population_Manager;
 
//------------------------------------------------------------------------------
enum TTypesOfNewt
{
    tton_Egg = 0,
    tton_Larva,
    tton_Juvenile,
    tton_Male,
    tton_Female,
    tton_Foobar
};
 
//---------------------------------------------------------------------------
 
enum TTypeOfNewtState
{
    toNewts_InitialState = 0,
      toNewts_Develop,
      toNewts_EvaluateLocation,
      toNewts_NextStage,
      toNewts_Remove,
      toNewts_Dispersal,
      toNewts_Migrate,
      toNewts_Breed,
      toNewts_Overwinter,
      toNewts_Die,
      toNewts_foobar
};
 
enum TTypeDirectedWalk {
    directedwalk_totally = 1,
    directedwalk_high = 3,
    directedwalk_medium = 5,
    directedwalk_low = 7,
    directedwalk_random = 8
};
 
class Newt_Base : public TAnimal {
public:
    // Attributes
    static double m_EggDevelopmentDDTotal;
    static double m_EggDevelopmentDDParameter;
    static double m_JuvenileDevelopmentSize;
    static double m_EggMortalityChance;
    static double m_JuvenileMortalityChance;
    static double m_AdultMortalityChance;
    static bool m_test_pesticide_egg;
    static bool m_test_pesticide_larva;
    static bool m_test_pesticide_terrestrial;
 
protected:
    // Attributes
    TTypeOfNewtState m_CurrentNewtState;
    unsigned m_Age;
    vector<unsigned> m_pondlist;
    Newt_Population_Manager*  m_OurPopulationManager;
    double m_body_burden;
    bool m_reproductiveinhibition;
public:
    // Methods
    Newt_Base(int a_x, int a_y, vector<unsigned> a_pond, Landscape* a_L, Newt_Population_Manager* a_NPM, bool a_reproinhib);
    void Init(vector<unsigned> a_pond, Newt_Population_Manager* a_NPM, bool a_reproinhib);
    void ReInit(int a_x, int a_y, vector<unsigned> a_pond, Landscape* a_L, Newt_Population_Manager* a_NPM, bool a_reproinhib);
    ~Newt_Base();
    virtual int WhatState() {
        return m_CurrentNewtState;
    }
    TTypeOfNewtState st_Develop( void ) {
        return TTypeOfNewtState(-1);
    }
    TTypeOfNewtState st_Movement( void ) {
        return TTypeOfNewtState(-1);
    }
    void st_Dying( void );
    virtual void BeginStep( void ) {
        ;
    }// NB this is not used in the Newt_Base code
    virtual void Step( void ) {
        ;
    }
    virtual void EndStep( void ) {
        ;
    }// NB this is not used in the Newt_Base code
    unsigned GetAge() {
        return m_Age;
    }
    void SetAge( unsigned a_age ) {
        m_Age = a_age;
    }
    unsigned GetHomePond() {
        return m_pondlist[ 0 ];
    }
    void SetHomePond( unsigned a_pond ) {
        m_pondlist[ 0 ] = a_pond;
    }
    void InternalPesticideHandlingAndResponse(double) {};
};
 
class Newt_Egg : public Newt_Base
{
protected:
    // Attributes
    double m_AgeDegrees;
public:
    // Attributes
    static double m_EggPPPThreshold;
    static double m_EggPPPElimRate;
    static double m_EggPPPEffectProbability;
    // Methods
    Newt_Egg(int a_x, int a_y, vector<unsigned> a_pond, Landscape* a_L, Newt_Population_Manager* a_NPM, bool a_reproinhib);
    void ReInit(int a_x, int a_y, vector<unsigned> a_pond, Landscape* a_L, Newt_Population_Manager* a_NPM, bool a_reproinhib);
    ~Newt_Egg();
    virtual void Init();
    virtual void Step( void );
    void InternalPesticideHandlingAndResponse();
protected:
    // Methods
    virtual TTypeOfNewtState st_Develop( void );
    virtual TTypeOfNewtState st_NextStage( void );
};
 
class Newt_Larva : public Newt_Egg
{
public:
    // Attributes
    static double m_LarvaPPPThreshold;
    static double m_LarvaPPPElimRate;
    static double m_LarvaPPPEffectProbability;
    static double m_LarvalFoodProportion;
    static double m_LarvaDevelopmentUpperSz;
    static double m_LarvaDevelopmentLowerSz;
    static double m_LarvaDevelopmentTime;
    static double m_NewtLarvaDailyGrowthIncrement;
    static double m_LarvaMortalityChance;
    // Methods
    Newt_Larva(int a_x, int a_y, vector<unsigned> a_pond, Landscape* a_L, Newt_Population_Manager* a_NPM, unsigned a_age, bool a_reproinhib);
    void ReInit(int a_x, int a_y, vector<unsigned> a_pond, Landscape* a_L, Newt_Population_Manager* a_NPM, unsigned a_age, bool a_reproinhib);
    ~Newt_Larva();
    virtual void Init(int a_age);
    virtual void Step( void );
    void InternalPesticideHandlingAndResponse();
protected:
    // Attributes
    double m_LarvalSize;
    // Methods
    virtual TTypeOfNewtState st_Develop( void );
    virtual TTypeOfNewtState st_NextStage( void );
};
 
class Newt_Juvenile : public Newt_Base
{
public:
    // Attributes
    static double m_JuvenilePPPThreshold_Min;
    static double m_JuvenilePPPThreshold_EnvConc;
    static double m_JuvenilePPPThreshold_Overspray;
    static double m_JuvenilePPPElimRate;
    static double m_JuvenilePPPEffectProbability_EnvConc;
    static double m_JuvenilePPPEffectProbability_Overspray;
    static double m_JuvenileDailyWeightGain;
    static int m_SimW;
    static int m_SimH;
    static double m_roadmortalityprob;
    static int m_newtwalkspeed;
    static int m_newtwalkstepsize;
    static double m_goodhabitatdispersalprob;
    static double m_poorhabitatdispersalprob;
    static double m_NewtDormancyTemperature;
    static double m_NewtDormancyHumidity;
    // Methods
    Newt_Juvenile(int a_x, int a_y, vector<unsigned> a_pond, Landscape* a_L, Newt_Population_Manager* a_NPM, unsigned a_age, bool a_reproinhib);
    ~Newt_Juvenile();
    virtual void ReInit(int a_x, int a_y, vector<unsigned> a_pond, Landscape* a_L, Newt_Population_Manager* a_NPM, unsigned a_age, bool a_reproinhib);
    virtual void Step( void );
    double GetWeight() {
        return m_weight;
    }
    void SetWeight( double a_weight ) {
        m_weight = a_weight;
    }
    void InternalPesticideHandlingAndResponse();
protected:
    // Attributes
    int m_InPond;
    double m_weight;
    unsigned m_OurVector;
    TTypesOfLandscapeElement m_CurrentHabitat;
    bool m_forcedisperse;
    // Methods
    virtual TTypeOfNewtState st_Develop( void );
    virtual TTypeOfNewtState st_EvaluateHabitat( void );
    virtual TTypeOfNewtState st_Disperse( void );
    virtual TTypeOfNewtState st_Overwinter( void );
    virtual TTypeOfNewtState st_NextStage( void );
    void MoveTo( TTypeDirectedWalk a_directedness, int a_stepsize, int a_steps );
    void NewtDoWalking( int &a_vector, int a_stepsize, int a_steps, int &vx, int &vy );
    void NewtDoWalkingCorrect( int &a_vector, int a_stepsize, int a_steps, int &vx, int &vy );
    int NewtMoveQuality( int a_x, int a_y, TTypesOfLandscapeElement & a_tole);
};
 
class Newt_Adult : public Newt_Juvenile {
public:
    // Attributes
    static double m_AdultPPPThreshold;
    static double m_AdultPPPElimRate;
    static double m_AdultPPPEffectProbability;
    static unsigned m_AdultLifespan;
    static int m_newtadultwalkspeed;
    // Methods
    Newt_Adult(int a_x, int a_y, vector<unsigned> a_pond, Landscape* a_L, Newt_Population_Manager* a_NPM, unsigned a_age, bool a_reproinhib);
    ~Newt_Adult();
    virtual void Init(int a_x, int a_y, vector<unsigned> a_pond, Landscape* a_L, Newt_Population_Manager* a_NPM, unsigned a_age);
    virtual void ReInit(int a_x, int a_y, vector<unsigned> a_pond, Landscape* a_L, Newt_Population_Manager* a_NPM, unsigned a_age, bool a_reproinhib);
    int GetInPond() {
        return m_InPond;
    }
    void SetInPond() {
        m_InPond = m_pondlist[0];
    }
protected:
    // Attributes
    int m_targetpondx;
    int m_targetpondy;
    // Methods
    void CalcMovementVector(void);
    bool AgeMortTest(void);
    virtual TTypeOfNewtState st_Develop(void);
    virtual TTypeOfNewtState st_Disperse(void);
    virtual TTypeOfNewtState st_Overwinter(void);
    virtual TTypeOfNewtState st_Migrate(void);
    virtual TTypeOfNewtState st_EvaluateHabitat(void);
};
 
class Newt_Male : public Newt_Adult {
public:
    Newt_Male(int a_x, int a_y, vector<unsigned> a_pond, Landscape* a_L, Newt_Population_Manager* a_NPM, unsigned a_age, bool a_reproinhib);
    ~Newt_Male();
    virtual void ReInit(int a_x, int a_y, vector<unsigned> a_pond, Landscape* a_L, Newt_Population_Manager* a_NPM, unsigned a_age, bool a_reproinhib);
    virtual void BeginStep(void);
    virtual void Step(void);
    virtual TTypeOfNewtState st_Develop(void);
    void InternalPesticideHandlingAndResponse();
protected:
    virtual TTypeOfNewtState st_EvaluateHabitat(void);
};
 
class Newt_Female : public Newt_Adult {
public:
    static unsigned m_eggproductionvolume;
    static unsigned m_eggdailyproductionvolume;
    Newt_Female(int a_x, int a_y, vector<unsigned> a_pond, Landscape* a_L, Newt_Population_Manager* a_NPM, unsigned a_age, bool a_reproinhib);
    ~Newt_Female();
    virtual void ReInit(int a_x, int a_y, vector<unsigned> a_pond, Landscape* a_L, Newt_Population_Manager* a_NPM, unsigned a_age, bool a_reproinhib);
    virtual void Step(void);
    void ResetEggProduction() {
        m_eggsproduced = 0;
    }
    void InternalPesticideHandlingAndResponse();
protected:
    unsigned m_eggsproduced;
    bool m_mated;
    virtual TTypeOfNewtState st_Develop(void);
    virtual TTypeOfNewtState st_Breed(void);
    virtual TTypeOfNewtState st_EvaluateHabitat(void);
};
 
#endif